# 第08章 TypeAliasRegistry类型别名注册器

# 8.1 引入

在Mybatis编程中我们经常会用到将某个bean作为参数类型parameterType或者结果返回值类型

在mybatis-config.xml中可以使用别名标签，最终会调用别名注册器进行注册：

<typeAliases>
    <!--自定义定义单个类的别名-->
    <typeAlias type="com.clare.model.OtaPackage" alias="otaPackage"/>
    <!--通过自动扫描形式自定义别名-->
    <package name="com.clare.model"/>
</typeAliases>

1
2
3
4
5
6

ResultType，所以很多时候我们需要把完成的Bean的包名在mapper文件中写上，如下：

<select id="selectUser" parameterType="com.dy.entity.User" resultType="com.dy.entity.User">    
    select * from user where c_id=#{id}    
</select>

1
2
3

Mybatis给我们提供了一种叫别名的机制，意思就是对某个具体的类设置别名，在mybatis的配置文件中配置如下：

<configuration>
    <typeAliases>
      <!--
      通过package, 可以直接指定package的名字， mybatis会自动扫描你指定包下面的javabean,
      并且默认设置一个别名，默认的名字为： javabean 的首字母小写的非限定类名来作为它的别名。
      也可在javabean 加上注解@Alias 来自定义别名， 例如： @Alias(user) 
      <package name="com.dy.entity"/>
       -->
      <typeAlias alias="user" type="com.dy.entity.User"/>
  </typeAliases>
  
  ......
  
</configuration>

1
2
3
4
5
6
7
8
9
10
11
12
13
14

之后mapper文件中的select可以写成如下格式：

<select id="selectUser" parameterType="user" resultType="user">  
    select * from user where c_id=#{id}  
</select>

1
2
3

这样就可以在使用某个bean时使用别名就可以了，不需要写完成的包名+类名

Configuration的构造器如下：

public Configuration() {
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

    typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
    typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
    typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

    typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
    typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
    typeAliasRegistry.registerAlias("LRU", LruCache.class);
    typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
    typeAliasRegistry.registerAlias("WEAK", WeakCache.class);

    typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);

    typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
    typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);

    typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
    typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
    typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
    typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
    typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
    typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
    typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);

    typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
    typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);

    languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
    languageRegistry.register(RawLanguageDriver.class);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

类型注册器TypeAliasRegistry主要是往Map中存储key为别名，value为类的全限定路径

分析XMLConfigBuilder类中对于typeAliases的解析，源码如下：

  //类别名解析
  private void typeAliasesElement(XNode parent) {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
		//如果子节点是package,那么就获取package节点的name属性
        if ("package".equals(child.getName())) {
          String typeAliasPackage = child.getStringAttribute("name");
          configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
        } else {
		//如果子节点是typeAlias节点，那么就获取alias属性和type的属性
          String alias = child.getStringAttribute("alias");
          String type = child.getStringAttribute("type");
          try {
			//通过type的值来加载获得类
            Class<?> clazz = Resources.classForName(type);
            if (alias == null) {
			//typeAliasRegistry会进行别名注册
              typeAliasRegistry.registerAlias(clazz);
            } else {
              typeAliasRegistry.registerAlias(alias, clazz);
            }
          } catch (ClassNotFoundException e) {
            throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
          }
        }
      }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

可以得知，解析alias来获得别名，解析type元素来获得类名，通过Resources.classForName(type)获得类信息，然后通过typeAliasRegistry.registerAlias(alias, clazz)将类别名注册到typeAliasRegistry中，这样就完成了mybatis中配置文件的解析。

# 8.2 TypeAliasRegistry

结构如下：

可见，TypeAliasRegistry内含一个HashMap集合TYPE_ALIASES（类型别名），key为String类型，value为字节码对象：

private final Map<String, Class<?>> TYPE_ALIASES = new HashMap<>();

提供了构造器TypeAliasRegistry()，别名注册registerAliases(...)，别名解析resolveAlias(String string)功能

# 8.2.1 构造器

public TypeAliasRegistry() {
    // 字符串
    registerAlias("string", String.class);

    // 8种基本数据类型（包装类）
    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);

    // 8种基本数据类型数组（包装类）
    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);

    // 8种基本数据类型（非包装类）
    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);

    // 8种基本数据类型数组（非包装类）
    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);

    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);

    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);

    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);

    registerAlias("ResultSet", ResultSet.class);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# 8.2.2 注册器

代码中重载了注册器

public void registerAliases(String packageName){
    registerAliases(packageName, Object.class);
}

// 根据包名和父类注
// 扫描指定package下的所有为superType类型的类，排除内部类和接口
// superType类型通常指定为Objec
public void registerAliases(String packageName, Class<?> superType){
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    for(Class<?> type : typeSet){
        // 忽略内部类和接口
        if (!type.isAnonymousClass() 
            && !type.isInterface() 
            && !type.isMemberClass()) {
            registerAlias(type);
        }
    }
}

// 根据类型获取类型的SimpleName设置为别名
// 如果有注解，则会以注解上的别名为新的别名
public void registerAlias(Class<?> type) {
    String alias = type.getSimpleName();
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
        alias = aliasAnnotation.value();
    }
    registerAlias(alias, type);
}

// 根据别名和类字节码注册
public void registerAlias(String alias, Class<?> value) {
    // 别名为null，报别名不能为空
    if (alias == null) {
        throw new TypeException("The parameter alias cannot be null");
    }
    // 将别名变为小写，设置为key
    String key = alias.toLowerCase(Locale.ENGLISH);
    // 如果map中已经含有了key或者value，则报错
    if (TYPE_ALIASES.containsKey(key) 
        && TYPE_ALIASES.get(key) != null 
        && !TYPE_ALIASES.get(key).equals(value)) {
        throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
    }
    // 往集合中添加key,value
    TYPE_ALIASES.put(key, value);
}

public void registerAlias(String alias, String value) {
    try {
        registerAlias(alias, Resources.classForName(value));
    } catch (ClassNotFoundException e) {
        throw new TypeException("Error registering type alias "+alias+" for "+value+". Cause: " + e, e);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# 8.2.3 解析器

// 通常调用后会强制类型转换
public <T> Class<T> resolveAlias(String string) {
    try {
        if (string == null) {
            return null;
        }
        // 别名小写
        String key = string.toLowerCase(Locale.ENGLISH);
        Class<T> value;
        if (TYPE_ALIASES.containsKey(key)) {
            value = (Class<T>) TYPE_ALIASES.get(key);
        } else {
            value = (Class<T>) Resources.classForName(string);
        }
        return value;
    } catch (ClassNotFoundException e) {
        throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + e, e);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 8.2.4 获取所有注册别名内容

public Map<String, Class<?>> getTypeAliases() {
    return Collections.unmodifiableMap(TYPE_ALIASES);
}

1
2
3

← 第07章 Configuration对象总结及其手动创建第09章 LanguageDriverRegistry语言驱动注册器 →